using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using 游戏服务器.地图类;
using 游戏服务器.数据类;
using 游戏服务器.网络类;

namespace 游戏服务器.模板类
{
	public class 技能实例
	{
		public 游戏技能 技能模板;

		public 技能数据 技能数据;

		public 地图对象 技能来源;

		public byte 动作编号;

		public byte 分段编号;

		public 地图实例 释放地图;

		public 地图对象 技能目标;

		public Point 技能锚点;

		public Point 释放位置;

		public DateTime 释放时间;

		public 技能实例 父类技能;

		public bool 目标借位;

		public Dictionary<int, 命中详情> 命中列表;

		public int 飞行耗时;

		public int 攻速缩减;

		public bool 经验增加;

		public DateTime 处理计时;

		public DateTime 预约时间;

		public SortedDictionary<int, 技能任务> 节点列表;

		public int 来源编号 => this.技能来源.地图编号;

		public byte 分组编号 => this.技能模板.技能分组编号;

		public byte 铭文编号 => this.技能模板.自身铭文编号;

		public ushort 技能编号 => this.技能模板.自身技能编号;

		public byte 技能等级
		{
			get
			{
				if (this.技能模板.绑定等级编号 != 0)
				{
					if (this.技能来源 is 玩家实例 玩家实例 && 玩家实例.主体技能表.TryGetValue(this.技能模板.绑定等级编号, out var v))
					{
						return v.技能等级.V;
					}
					if (this.技能来源 is 陷阱实例 陷阱实例 && 陷阱实例.陷阱来源 is 玩家实例 玩家实例2 && 玩家实例2.主体技能表.TryGetValue(this.技能模板.绑定等级编号, out var v2))
					{
						return v2.技能等级.V;
					}
					return 0;
				}
				return 0;
			}
		}

		public bool 检查计数 => this.技能模板.检查技能计数;

		public 技能实例(地图对象 技能来源, 游戏技能 技能模板, 技能数据 技能数据, byte 动作编号, 地图实例 释放地图, Point 释放位置, 地图对象 技能目标, Point 技能锚点, 技能实例 父类技能, Dictionary<int, 命中详情> 命中列表 = null, bool 目标借位 = false)
		{
			Class2.sov79KqzBKBU1();
			//base._002Ector();
			this.技能来源 = 技能来源;
			this.技能模板 = 技能模板;
			this.技能数据 = 技能数据;
			this.动作编号 = 动作编号;
			this.释放地图 = 释放地图;
			this.释放位置 = 释放位置;
			this.技能目标 = 技能目标;
			this.技能锚点 = 技能锚点;
			this.父类技能 = 父类技能;
			this.释放时间 = 主程.当前时间;
			this.目标借位 = 目标借位;
			this.命中列表 = 命中列表 ?? new Dictionary<int, 命中详情>();
			this.节点列表 = new SortedDictionary<int, 技能任务>(技能模板.节点列表);
			if (this.节点列表.Count != 0)
			{
				this.技能来源.技能任务.Add(this);
				this.预约时间 = this.释放时间.AddMilliseconds(this.飞行耗时 + this.节点列表.First().Key);
			}
		}

		public void 处理任务()
		{
			/*_003C_003Ec__DisplayClass32_0 CS_0024_003C_003E8__locals0;
			CS_0024_003C_003E8__locals0 = new _003C_003Ec__DisplayClass32_0();
			CS_0024_003C_003E8__locals0._003C_003E4__this = this;*/
			if ((this.预约时间 - this.处理计时).TotalMilliseconds > 5.0 && 主程.当前时间 < this.预约时间)
			{
				return;
			}
			KeyValuePair<int, 技能任务> keyValuePair;
			keyValuePair = this.节点列表.First();
			this.节点列表.Remove(keyValuePair.Key);
			技能任务 value;
			value = keyValuePair.Value;
			this.处理计时 = this.预约时间;
			if (value != null)
			{
				if (value is A_00_触发子类技能 a_00_触发子类技能)
				{
					if (游戏技能.数据表.TryGetValue(a_00_触发子类技能.触发技能名字, out var value2))
					{
						bool flag;
						flag = true;
						if (a_00_触发子类技能.计算触发概率)
						{
							flag = ((!a_00_触发子类技能.计算幸运概率) ? 计算类.计算概率(a_00_触发子类技能.技能触发概率 + ((a_00_触发子类技能.增加概率Buff == 0 || !this.技能来源.Buff列表.ContainsKey(a_00_触发子类技能.增加概率Buff)) ? 0f : a_00_触发子类技能.Buff增加系数)) : 计算类.计算概率(计算类.计算幸运(this.技能来源[游戏对象属性.幸运等级])));
						}
						if (flag && a_00_触发子类技能.验证自身Buff)
						{
							if (!this.技能来源.Buff列表.ContainsKey(a_00_触发子类技能.自身Buff编号))
							{
								flag = false;
							}
							else if (a_00_触发子类技能.触发成功移除)
							{
								this.技能来源.移除Buff时处理(a_00_触发子类技能.自身Buff编号);
							}
						}
						if (flag && a_00_触发子类技能.验证铭文技能 && this.技能来源 is 玩家实例 玩家实例)
						{
							int num;
							num = (int)a_00_触发子类技能.所需铭文编号 / 10;
							int num2;
							num2 = (int)a_00_触发子类技能.所需铭文编号 % 10;
							flag = 玩家实例.主体技能表.TryGetValue((ushort)num, out var v) && ((!a_00_触发子类技能.同组铭文无效) ? (num2 == 0 || num2 == v.铭文编号) : (num2 == v.铭文编号));
						}
						if (flag)
						{
							switch (a_00_触发子类技能.技能触发方式)
							{
							case 技能触发方式.原点位置绝对触发:
								new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, this.释放位置, this.技能目标, this.释放位置, this);
								break;
							case 技能触发方式.锚点位置绝对触发:
								new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, this.释放位置, this.技能目标, this.技能锚点, this);
								break;
							case 技能触发方式.刺杀位置绝对触发:
								new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, this.释放位置, this.技能目标, 计算类.前方坐标(this.释放位置, this.技能锚点, 2), this);
								break;
							case 技能触发方式.目标命中绝对触发:
								foreach (KeyValuePair<int, 命中详情> item in this.命中列表)
								{
									if ((item.Value.技能反馈 & 技能命中反馈.闪避) == 0 && (item.Value.技能反馈 & 技能命中反馈.丢失) == 0)
									{
										new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, (this.父类技能 == null) ? this.释放位置 : this.技能锚点, item.Value.技能目标, item.Value.技能目标.当前坐标, this);
									}
								}
								break;
							case 技能触发方式.怪物死亡绝对触发:
								foreach (KeyValuePair<int, 命中详情> item2 in this.命中列表)
								{
									if (item2.Value.技能目标 is 怪物实例 && (item2.Value.技能反馈 & 技能命中反馈.死亡) != 0)
									{
										new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, this.释放位置, null, item2.Value.技能目标.当前坐标, this);
									}
								}
								break;
							case 技能触发方式.怪物死亡换位触发:
								foreach (KeyValuePair<int, 命中详情> item3 in this.命中列表)
								{
									if (item3.Value.技能目标 is 怪物实例 && (item3.Value.技能反馈 & 技能命中反馈.死亡) != 0)
									{
										new 技能实例(this.技能来源, value2, null, item3.Value.技能目标.动作编号++, this.释放地图, item3.Value.技能目标.当前坐标, item3.Value.技能目标, item3.Value.技能目标.当前坐标, this, null, 目标借位: true);
									}
								}
								break;
							case 技能触发方式.怪物命中绝对触发:
								foreach (KeyValuePair<int, 命中详情> item4 in this.命中列表)
								{
									if (item4.Value.技能目标 is 怪物实例 && (item4.Value.技能反馈 & 技能命中反馈.丢失) == 0)
									{
										new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, (this.父类技能 == null) ? this.释放位置 : this.技能锚点, item4.Value.技能目标, item4.Value.技能目标.当前坐标, this);
									}
								}
								break;
							case 技能触发方式.无目标锚点位触发:
								if (this.命中列表.Count == 0 || this.命中列表.Values.FirstOrDefault((命中详情 O) => O.技能反馈 != 技能命中反馈.丢失) == null)
								{
									new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, this.释放位置, null, this.技能锚点, this);
								}
								break;
							case 技能触发方式.目标位置绝对触发:
								foreach (KeyValuePair<int, 命中详情> item5 in this.命中列表)
								{
									new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, this.释放位置, item5.Value.技能目标, item5.Value.技能目标.当前坐标, this);
								}
								break;
							case 技能触发方式.正手反手随机触发:
							{
								if (计算类.计算概率(0.5f) && 游戏技能.数据表.TryGetValue(a_00_触发子类技能.反手技能名字, out var value3))
								{
									new 技能实例(this.技能来源, value3, this.技能数据, this.动作编号, this.释放地图, this.释放位置, null, this.技能锚点, this);
								}
								else
								{
									new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, this.释放位置, null, this.技能锚点, this);
								}
								break;
							}
							case 技能触发方式.目标死亡绝对触发:
								foreach (KeyValuePair<int, 命中详情> item6 in this.命中列表)
								{
									if ((item6.Value.技能反馈 & 技能命中反馈.死亡) != 0)
									{
										new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, this.释放位置, null, item6.Value.技能目标.当前坐标, this);
									}
								}
								break;
							case 技能触发方式.目标闪避绝对触发:
								foreach (KeyValuePair<int, 命中详情> item7 in this.命中列表)
								{
									if ((item7.Value.技能反馈 & 技能命中反馈.闪避) != 0)
									{
										new 技能实例(this.技能来源, value2, this.技能数据, this.动作编号, this.释放地图, this.释放位置, null, item7.Value.技能目标.当前坐标, this);
									}
								}
								break;
							}
						}
					}
				}
				else
				{
					A_01_触发对象Buff 触发Buff = value as A_01_触发对象Buff;
					if (触发Buff != null)
					{
						bool flag2;
						flag2 = false;
						if (触发Buff.角色自身添加)
						{
							bool flag3;
							flag3 = true;
							if (!计算类.计算概率(触发Buff.Buff触发概率))
							{
								flag3 = false;
							}
							if (flag3 && 触发Buff.验证铭文技能 && this.技能来源 is 玩家实例 玩家实例2)
							{
								int num3;
								num3 = (int)触发Buff.所需铭文编号 / 10;
								int num4;
								num4 = (int)触发Buff.所需铭文编号 % 10;
								flag3 = 玩家实例2.主体技能表.TryGetValue((ushort)num3, out var v2) && ((!触发Buff.同组铭文无效) ? (num4 == 0 || num4 == v2.铭文编号) : (num4 == v2.铭文编号));
							}
							if (flag3 && 触发Buff.验证自身Buff)
							{
								if (!this.技能来源.Buff列表.ContainsKey(触发Buff.自身Buff编号))
								{
									flag3 = false;
								}
								else
								{
									if (触发Buff.触发成功移除)
									{
										this.技能来源.移除Buff时处理(触发Buff.自身Buff编号);
									}
									if (触发Buff.移除伴生Buff)
									{
										this.技能来源.移除Buff时处理(触发Buff.移除伴生编号);
									}
								}
							}
							if (flag3 && 触发Buff.验证分组Buff && this.技能来源.Buff列表.Values.FirstOrDefault((Buff数据 O) => O.Buff分组 == 触发Buff.Buff分组编号) == null)
							{
								flag3 = false;
							}
							if (flag3 && 触发Buff.验证目标Buff && this.命中列表.Values.FirstOrDefault((命中详情 O) => (O.技能反馈 & 技能命中反馈.闪避) == 0 && (O.技能反馈 & 技能命中反馈.丢失) == 0 && O.技能目标.Buff列表.TryGetValue(触发Buff.目标Buff编号, out var v10) && v10.当前层数.V >= 触发Buff.所需Buff层数) == null)
							{
								flag3 = false;
							}
							if (flag3 && 触发Buff.验证目标类型 && this.命中列表.Values.FirstOrDefault((命中详情 O) => (O.技能反馈 & 技能命中反馈.闪避) == 0 && (O.技能反馈 & 技能命中反馈.丢失) == 0 && O.技能目标.特定类型(技能来源, 触发Buff.所需目标类型)) == null)
							{
								flag3 = false;
							}
							if (flag3)
							{
								this.技能来源.添加Buff时处理(触发Buff.触发Buff编号, this.技能来源);
								if (触发Buff.伴生Buff编号 > 0)
								{
									this.技能来源.添加Buff时处理(触发Buff.伴生Buff编号, this.技能来源);
								}
								flag2 = true;
							}
						}
						else
						{
							bool flag4;
							flag4 = true;
							if (触发Buff.验证自身Buff)
							{
								if (!this.技能来源.Buff列表.ContainsKey(触发Buff.自身Buff编号))
								{
									flag4 = false;
								}
								else
								{
									if (触发Buff.触发成功移除)
									{
										this.技能来源.移除Buff时处理(触发Buff.自身Buff编号);
									}
									if (触发Buff.移除伴生Buff)
									{
										this.技能来源.移除Buff时处理(触发Buff.移除伴生编号);
									}
								}
							}
							if (flag4 && 触发Buff.验证分组Buff && this.技能来源.Buff列表.Values.FirstOrDefault((Buff数据 O) => O.Buff分组 == 触发Buff.Buff分组编号) == null)
							{
								flag4 = false;
							}
							if (flag4 && 触发Buff.验证铭文技能 && this.技能来源 is 玩家实例 玩家实例3)
							{
								int num5;
								num5 = (int)触发Buff.所需铭文编号 / 10;
								int num6;
								num6 = (int)触发Buff.所需铭文编号 % 10;
								flag4 = 玩家实例3.主体技能表.TryGetValue((ushort)num5, out var v3) && ((!触发Buff.同组铭文无效) ? (num6 == 0 || num6 == v3.铭文编号) : (num6 == v3.铭文编号));
							}
							if (flag4)
							{
								foreach (KeyValuePair<int, 命中详情> item8 in this.命中列表)
								{
									bool flag5;
									flag5 = true;
									if ((item8.Value.技能反馈 & (技能命中反馈.闪避 | 技能命中反馈.丢失)) != 0)
									{
										flag5 = false;
									}
									if (flag5 && !计算类.计算概率(触发Buff.Buff触发概率))
									{
										flag5 = false;
									}
									if (flag5 && 触发Buff.验证目标类型 && !item8.Value.技能目标.特定类型(this.技能来源, 触发Buff.所需目标类型))
									{
										flag5 = false;
									}
									if (flag5 && 触发Buff.验证目标Buff)
									{
										flag5 = item8.Value.技能目标.Buff列表.TryGetValue(触发Buff.目标Buff编号, out var v4) && v4.当前层数.V >= 触发Buff.所需Buff层数;
									}
									if (flag5)
									{
										item8.Value.技能目标.添加Buff时处理(触发Buff.触发Buff编号, this.技能来源);
										if (触发Buff.伴生Buff编号 > 0)
										{
											item8.Value.技能目标.添加Buff时处理(触发Buff.伴生Buff编号, this.技能来源);
										}
										flag2 = true;
									}
								}
							}
						}
						if (flag2 && 触发Buff.增加技能经验 && this.技能来源 is 玩家实例 玩家实例4)
						{
							玩家实例4.技能增加经验(触发Buff.经验技能编号);
						}
					}
					else if (value is A_02_触发陷阱技能 a_02_触发陷阱技能)
					{
						/*_003C_003Ec__DisplayClass32_1 CS_0024_003C_003E8__locals1;
						CS_0024_003C_003E8__locals1 = new _003C_003Ec__DisplayClass32_1();*/
						if (技能陷阱.数据表.TryGetValue(a_02_触发陷阱技能.触发陷阱技能, out 技能陷阱 陷阱模板 ))
						{
							int num7;
							num7 = 0;
							Point[] array;
							array = 计算类.技能范围(this.技能锚点, 计算类.计算方向(this.释放位置, this.技能锚点), a_02_触发陷阱技能.触发陷阱数量);
							foreach (Point 坐标 in array)
							{
								if (!this.释放地图.地形阻塞(坐标) && (陷阱模板.陷阱允许叠加 || this.释放地图[坐标].FirstOrDefault((地图对象 O) => O is 陷阱实例 陷阱实例2 && 陷阱实例2.陷阱分组编号 != 0 && 陷阱实例2.陷阱分组编号 == 陷阱模板.分组编号) == null))
								{
									this.技能来源.陷阱列表.Add(new 陷阱实例(this.技能来源, 陷阱模板, this.释放地图, 坐标));
									num7++;
								}
							}
							if (num7 != 0 && a_02_触发陷阱技能.经验技能编号 != 0 && this.技能来源 is 玩家实例 玩家实例5)
							{
								玩家实例5.技能增加经验(a_02_触发陷阱技能.经验技能编号);
							}
						}
					}
					else if (value is B_00_技能切换通知 b_00_技能切换通知)
					{
						if (this.技能来源.Buff列表.ContainsKey(b_00_技能切换通知.技能标记编号))
						{
							if (b_00_技能切换通知.允许移除标记)
							{
								this.技能来源.移除Buff时处理(b_00_技能切换通知.技能标记编号);
							}
						}
						else if (游戏Buff.数据表.ContainsKey(b_00_技能切换通知.技能标记编号))
						{
							this.技能来源.添加Buff时处理(b_00_技能切换通知.技能标记编号, this.技能来源);
						}
					}
					else if (value is B_01_技能释放通知 b_01_技能释放通知)
					{
						if (b_01_技能释放通知.调整角色朝向)
						{
							游戏方向 游戏方向;
							游戏方向 = 计算类.计算方向(this.释放位置, this.技能锚点);
							if (游戏方向 == this.技能来源.当前方向)
							{
								this.技能来源.发送封包(new 对象转动方向
								{
									对象编号 = this.技能来源.地图编号,
									对象朝向 = (ushort)游戏方向,
									转向耗时 = ((!(this.技能来源 is 玩家实例)) ? ((ushort)1) : ((ushort)0))
								});
							}
							else
							{
								this.技能来源.当前方向 = 计算类.计算方向(this.释放位置, this.技能锚点);
							}
						}
						if (b_01_技能释放通知.移除技能标记 && this.技能模板.技能标记编号 != 0)
						{
							this.技能来源.移除Buff时处理(this.技能模板.技能标记编号);
						}
						if (b_01_技能释放通知.自身冷却时间 != 0 || b_01_技能释放通知.Buff增加冷却)
						{
							if (this.检查计数 && this.技能来源 is 玩家实例 玩家实例6)
							{
								if (--this.技能数据.剩余次数.V <= 0)
								{
									this.技能来源.冷却记录[this.技能编号 | 0x1000000] = this.释放时间.AddMilliseconds((this.技能数据.计数时间 - 主程.当前时间).TotalMilliseconds);
								}
								玩家实例6.网络连接.发送封包(new 同步技能计数
								{
									技能编号 = this.技能数据.技能编号.V,
									技能计数 = this.技能数据.剩余次数.V,
									技能冷却 = (int)(this.技能数据.计数时间 - 主程.当前时间).TotalMilliseconds
								});
							}
							else if (b_01_技能释放通知.自身冷却时间 > 0 || b_01_技能释放通知.Buff增加冷却)
							{
								int num8;
								num8 = b_01_技能释放通知.自身冷却时间;
								if (b_01_技能释放通知.Buff增加冷却 && this.技能来源.Buff列表.ContainsKey(b_01_技能释放通知.增加冷却Buff))
								{
									num8 += b_01_技能释放通知.冷却增加时间;
								}
								DateTime dateTime;
								dateTime = this.释放时间.AddMilliseconds(num8);
								DateTime dateTime2;
								dateTime2 = (this.技能来源.冷却记录.ContainsKey(this.技能编号 | 0x1000000) ? this.技能来源.冷却记录[this.技能编号 | 0x1000000] : default(DateTime));
								if (num8 > 0 && dateTime > dateTime2)
								{
									this.技能来源.冷却记录[this.技能编号 | 0x1000000] = dateTime;
									this.技能来源.发送封包(new 添加技能冷却
									{
										冷却编号 = (this.技能编号 | 0x1000000),
										冷却时间 = num8
									});
								}
							}
						}
						if (this.技能来源 is 玩家实例 玩家实例7 && b_01_技能释放通知.分组冷却时间 != 0 && this.分组编号 != 0)
						{
							DateTime dateTime3;
							dateTime3 = this.释放时间.AddMilliseconds(b_01_技能释放通知.分组冷却时间);
							if (dateTime3 > (玩家实例7.冷却记录.ContainsKey(this.分组编号 | 0) ? 玩家实例7.冷却记录[this.分组编号 | 0] : default(DateTime)))
							{
								玩家实例7.冷却记录[this.分组编号 | 0] = dateTime3;
							}
							this.技能来源.发送封包(new 添加技能冷却
							{
								冷却编号 = (this.分组编号 | 0),
								冷却时间 = b_01_技能释放通知.分组冷却时间
							});
						}
						if (b_01_技能释放通知.角色忙绿时间 != 0)
						{
							this.技能来源.忙碌时间 = this.释放时间.AddMilliseconds(b_01_技能释放通知.角色忙绿时间);
						}
						if (b_01_技能释放通知.发送释放通知)
						{
							this.技能来源.发送封包(new 开始释放技能
							{
								对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
								技能编号 = this.技能编号,
								技能等级 = this.技能等级,
								技能铭文 = this.铭文编号,
								锚点坐标 = this.技能锚点,
								动作编号 = this.动作编号,
								目标编号 = (this.技能目标?.地图编号 ?? 0),
								锚点高度 = this.释放地图.地形高度(this.技能锚点)
							});
						}
					}
					else if (value is B_02_技能命中通知 b_02_技能命中通知)
					{
						if (b_02_技能命中通知.命中扩展通知)
						{
							this.技能来源.发送封包(new 触发技能扩展
							{
								对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
								技能编号 = this.技能编号,
								技能等级 = this.技能等级,
								技能铭文 = this.铭文编号,
								动作编号 = this.动作编号,
								命中描述 = 命中详情.命中描述(this.命中列表, this.飞行耗时)
							});
						}
						else
						{
							this.技能来源.发送封包(new 触发技能正常
							{
								对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
								技能编号 = this.技能编号,
								技能等级 = this.技能等级,
								技能铭文 = this.铭文编号,
								动作编号 = this.动作编号,
								命中描述 = 命中详情.命中描述(this.命中列表, this.飞行耗时)
							});
						}
						if (b_02_技能命中通知.计算飞行耗时)
						{
							this.飞行耗时 = 计算类.网格距离(this.释放位置, this.技能锚点) * b_02_技能命中通知.单格飞行耗时;
						}
					}
					else if (value is B_03_前摇结束通知 b_03_前摇结束通知)
					{
						if (b_03_前摇结束通知.计算攻速缩减)
						{
							this.攻速缩减 = 计算类.数值限制(计算类.计算攻速(-5), this.攻速缩减 + 计算类.计算攻速(this.技能来源[游戏对象属性.攻击速度]), 计算类.计算攻速(5));
							if (this.攻速缩减 != 0)
							{
								foreach (KeyValuePair<int, 技能任务> item9 in this.节点列表)
								{
									if (item9.Value is B_04_后摇结束通知)
									{
										int j;
										for (j = item9.Key - this.攻速缩减; this.节点列表.ContainsKey(j); j++)
										{
										}
										this.节点列表.Remove(item9.Key);
										this.节点列表.Add(j, item9.Value);
										break;
									}
								}
							}
						}
						if (b_03_前摇结束通知.禁止行走时间 != 0)
						{
							this.技能来源.行走时间 = this.释放时间.AddMilliseconds(b_03_前摇结束通知.禁止行走时间);
						}
						if (b_03_前摇结束通知.禁止奔跑时间 != 0)
						{
							this.技能来源.奔跑时间 = this.释放时间.AddMilliseconds(b_03_前摇结束通知.禁止奔跑时间);
						}
						if (b_03_前摇结束通知.角色硬直时间 != 0)
						{
							this.技能来源.硬直时间 = this.释放时间.AddMilliseconds(b_03_前摇结束通知.计算攻速缩减 ? (b_03_前摇结束通知.角色硬直时间 - this.攻速缩减) : b_03_前摇结束通知.角色硬直时间);
						}
						if (b_03_前摇结束通知.发送结束通知)
						{
							this.技能来源.发送封包(new 触发技能正常
							{
								对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
								技能编号 = this.技能编号,
								技能等级 = this.技能等级,
								技能铭文 = this.铭文编号,
								动作编号 = this.动作编号
							});
						}
						if (b_03_前摇结束通知.解除技能陷阱 && this.技能来源 is 陷阱实例 陷阱实例)
						{
							陷阱实例.陷阱消失处理();
						}
					}
					else if (value is B_04_后摇结束通知 b_04_后摇结束通知)
					{
						this.技能来源.发送封包(new 技能释放完成
						{
							技能编号 = this.技能编号,
							动作编号 = this.动作编号
						});
						if (b_04_后摇结束通知.后摇结束死亡)
						{
							this.技能来源.自身死亡处理(null, 技能击杀: false);
						}
					}
					else if (value is C_00_计算技能锚点 c_00_计算技能锚点)
					{
						if (c_00_计算技能锚点.计算当前位置)
						{
							this.技能目标 = null;
							if (c_00_计算技能锚点.计算当前方向)
							{
								this.技能锚点 = 计算类.前方坐标(this.技能来源.当前坐标, this.技能来源.当前方向, c_00_计算技能锚点.技能最近距离);
							}
							else
							{
								this.技能锚点 = 计算类.前方坐标(this.技能来源.当前坐标, this.技能锚点, c_00_计算技能锚点.技能最近距离);
							}
						}
						else if (计算类.网格距离(this.释放位置, this.技能锚点) > c_00_计算技能锚点.技能最远距离)
						{
							this.技能目标 = null;
							this.技能锚点 = 计算类.前方坐标(this.释放位置, this.技能锚点, c_00_计算技能锚点.技能最远距离);
						}
						else if (计算类.网格距离(this.释放位置, this.技能锚点) < c_00_计算技能锚点.技能最近距离)
						{
							this.技能目标 = null;
							if (this.释放位置 == this.技能锚点)
							{
								this.技能锚点 = 计算类.前方坐标(this.释放位置, this.技能来源.当前方向, c_00_计算技能锚点.技能最近距离);
							}
							else
							{
								this.技能锚点 = 计算类.前方坐标(this.释放位置, this.技能锚点, c_00_计算技能锚点.技能最近距离);
							}
						}
					}
					else if (value is C_01_计算命中目标 c_01_计算命中目标)
					{
						if (c_01_计算命中目标.清空命中列表)
						{
							this.命中列表 = new Dictionary<int, 命中详情>();
						}
						if (c_01_计算命中目标.技能能否穿墙 || !this.释放地图.地形遮挡(this.释放位置, this.技能锚点))
						{
							switch (c_01_计算命中目标.技能锁定方式)
							{
							case 技能锁定类型.锁定自身:
								this.技能来源.被技能命中处理(this, c_01_计算命中目标);
								break;
							case 技能锁定类型.锁定目标:
								this.技能目标?.被技能命中处理(this, c_01_计算命中目标);
								break;
							case 技能锁定类型.锁定自身坐标:
							{
								Point[] array;
								array = 计算类.技能范围(this.技能来源.当前坐标, 计算类.计算方向(this.释放位置, this.技能锚点), c_01_计算命中目标.技能范围类型);
								foreach (Point 坐标4 in array)
								{
									foreach (地图对象 item10 in this.释放地图[坐标4])
									{
										item10.被技能命中处理(this, c_01_计算命中目标);
									}
								}
								break;
							}
							case 技能锁定类型.锁定目标坐标:
							{
								Point[] array;
								array = 计算类.技能范围(this.技能目标?.当前坐标 ?? this.技能锚点, 计算类.计算方向(this.释放位置, this.技能锚点), c_01_计算命中目标.技能范围类型);
								foreach (Point 坐标3 in array)
								{
									foreach (地图对象 item11 in this.释放地图[坐标3])
									{
										item11.被技能命中处理(this, c_01_计算命中目标);
									}
								}
								break;
							}
							case 技能锁定类型.锁定锚点坐标:
							{
								Point[] array;
								array = 计算类.技能范围(this.技能锚点, 计算类.计算方向(this.释放位置, this.技能锚点), c_01_计算命中目标.技能范围类型);
								foreach (Point 坐标5 in array)
								{
									foreach (地图对象 item12 in this.释放地图[坐标5])
									{
										item12.被技能命中处理(this, c_01_计算命中目标);
									}
								}
								break;
							}
							case 技能锁定类型.放空锁定自身:
							{
								Point[] array;
								array = 计算类.技能范围(this.技能锚点, 计算类.计算方向(this.释放位置, this.技能锚点), c_01_计算命中目标.技能范围类型);
								foreach (Point 坐标2 in array)
								{
									foreach (地图对象 item13 in this.释放地图[坐标2])
									{
										item13.被技能命中处理(this, c_01_计算命中目标);
									}
								}
								if (this.命中列表.Count == 0)
								{
									this.技能来源.被技能命中处理(this, c_01_计算命中目标);
								}
								break;
							}
							}
						}
						if (this.命中列表.Count == 0 && c_01_计算命中目标.放空结束技能)
						{
							if (c_01_计算命中目标.发送中断通知)
							{
								this.技能来源.发送封包(new 技能释放中断
								{
									对象编号 = this.技能来源.地图编号,
									技能编号 = this.技能编号,
									技能等级 = this.技能等级,
									技能铭文 = this.铭文编号,
									动作编号 = this.动作编号,
									技能分段 = this.分段编号
								});
							}
							this.技能来源.技能任务.Remove(this);
							return;
						}
						if (c_01_计算命中目标.补发释放通知)
						{
							this.技能来源.发送封包(new 开始释放技能
							{
								对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
								技能编号 = this.技能编号,
								技能等级 = this.技能等级,
								技能铭文 = this.铭文编号,
								目标编号 = (this.技能目标?.地图编号 ?? 0),
								锚点坐标 = this.技能锚点,
								锚点高度 = this.释放地图.地形高度(this.技能锚点),
								动作编号 = this.动作编号
							});
						}
						if (this.命中列表.Count != 0 && c_01_计算命中目标.攻速提升类型 != 0 && this.命中列表[0].技能目标.特定类型(this.技能来源, c_01_计算命中目标.攻速提升类型))
						{
							this.攻速缩减 = 计算类.数值限制(计算类.计算攻速(-5), this.攻速缩减 + 计算类.计算攻速(c_01_计算命中目标.攻速提升幅度), 计算类.计算攻速(5));
						}
						if (c_01_计算命中目标.清除目标状态 && c_01_计算命中目标.清除状态列表.Count != 0)
						{
							foreach (KeyValuePair<int, 命中详情> item14 in this.命中列表)
							{
								if ((item14.Value.技能反馈 & 技能命中反馈.闪避) != 0 || (item14.Value.技能反馈 & 技能命中反馈.丢失) != 0)
								{
									continue;
								}
								foreach (ushort item15 in c_01_计算命中目标.清除状态列表.ToList())
								{
									item14.Value.技能目标.移除Buff时处理(item15);
								}
							}
						}
						if (c_01_计算命中目标.触发被动技能 && this.命中列表.Count != 0 && 计算类.计算概率(c_01_计算命中目标.触发被动概率))
						{
							this.技能来源[游戏对象属性.技能标志] = 1;
						}
						if (c_01_计算命中目标.增加技能经验 && this.命中列表.Count != 0)
						{
							(this.技能来源 as 玩家实例).技能增加经验(c_01_计算命中目标.经验技能编号);
						}
						if (c_01_计算命中目标.计算飞行耗时 && c_01_计算命中目标.单格飞行耗时 != 0)
						{
							this.飞行耗时 = 计算类.网格距离(this.释放位置, this.技能锚点) * c_01_计算命中目标.单格飞行耗时;
						}
						if (c_01_计算命中目标.技能命中通知)
						{
							this.技能来源.发送封包(new 触发技能正常
							{
								对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
								技能编号 = this.技能编号,
								技能等级 = this.技能等级,
								技能铭文 = this.铭文编号,
								动作编号 = this.动作编号,
								命中描述 = 命中详情.命中描述(this.命中列表, this.飞行耗时)
							});
						}
						if (c_01_计算命中目标.技能扩展通知)
						{
							this.技能来源.发送封包(new 触发技能扩展
							{
								对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
								技能编号 = this.技能编号,
								技能等级 = this.技能等级,
								技能铭文 = this.铭文编号,
								动作编号 = this.动作编号,
								命中描述 = 命中详情.命中描述(this.命中列表, this.飞行耗时)
							});
						}
					}
					else if (value is C_02_计算目标伤害 c_02_计算目标伤害)
					{
						float num9;
						num9 = 1f;
						foreach (KeyValuePair<int, 命中详情> item16 in this.命中列表)
						{
							if (c_02_计算目标伤害.点爆命中目标 && item16.Value.技能目标.Buff列表.ContainsKey(c_02_计算目标伤害.点爆标记编号))
							{
								item16.Value.技能目标.移除Buff时处理(c_02_计算目标伤害.点爆标记编号);
							}
							else if (c_02_计算目标伤害.点爆命中目标 && c_02_计算目标伤害.失败添加层数)
							{
								item16.Value.技能目标.添加Buff时处理(c_02_计算目标伤害.点爆标记编号, this.技能来源);
								continue;
							}
							item16.Value.技能目标.被动受伤时处理(this, c_02_计算目标伤害, item16.Value, num9);
							if ((item16.Value.技能反馈 & 技能命中反馈.丢失) == 0)
							{
								if (c_02_计算目标伤害.数量衰减伤害)
								{
									num9 = Math.Max(c_02_计算目标伤害.伤害衰减下限, num9 - c_02_计算目标伤害.伤害衰减系数);
								}
								this.技能来源.发送封包(new 触发命中特效
								{
									对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
									技能编号 = this.技能编号,
									技能等级 = this.技能等级,
									技能铭文 = this.铭文编号,
									动作编号 = this.动作编号,
									目标编号 = item16.Value.技能目标.地图编号,
									技能反馈 = (ushort)item16.Value.技能反馈,
									技能伤害 = -item16.Value.技能伤害,
									招架伤害 = item16.Value.招架伤害
								});
							}
						}
						if (c_02_计算目标伤害.目标死亡回复)
						{
							foreach (KeyValuePair<int, 命中详情> item17 in this.命中列表)
							{
								if ((item17.Value.技能反馈 & 技能命中反馈.死亡) != 0 && item17.Value.技能目标.特定类型(this.技能来源, c_02_计算目标伤害.回复限定类型))
								{
									int num10;
									num10 = c_02_计算目标伤害.体力回复基数;
									if (c_02_计算目标伤害.等级差减回复)
									{
										int 数值;
										数值 = this.技能来源.当前等级 - item17.Value.技能目标.当前等级 - c_02_计算目标伤害.减回复等级差;
										int num11;
										num11 = c_02_计算目标伤害.零回复等级差 - c_02_计算目标伤害.减回复等级差;
										num10 = (int)((float)num10 - (float)num10 * ((float)计算类.数值限制(0, 数值, num11) / (float)num11));
									}
									if (num10 > 0)
									{
										this.技能来源.当前体力 += num10;
										this.技能来源.发送封包(new 体力变动飘字
										{
											血量变化 = num10,
											对象编号 = this.技能来源.地图编号
										});
									}
								}
							}
						}
						if (c_02_计算目标伤害.击杀减少冷却)
						{
							int num12;
							num12 = 0;
							foreach (KeyValuePair<int, 命中详情> item18 in this.命中列表)
							{
								if ((item18.Value.技能反馈 & 技能命中反馈.死亡) != 0 && item18.Value.技能目标.特定类型(this.技能来源, c_02_计算目标伤害.冷却减少类型))
								{
									num12 += c_02_计算目标伤害.冷却减少时间;
								}
							}
							if (num12 > 0)
							{
								if (this.技能来源.冷却记录.TryGetValue(c_02_计算目标伤害.冷却减少技能 | 0x1000000, out var v5))
								{
									v5 -= TimeSpan.FromMilliseconds(num12);
									this.技能来源.冷却记录[c_02_计算目标伤害.冷却减少技能 | 0x1000000] = v5;
									this.技能来源.发送封包(new 添加技能冷却
									{
										冷却编号 = (c_02_计算目标伤害.冷却减少技能 | 0x1000000),
										冷却时间 = Math.Max(0, (int)(v5 - 主程.当前时间).TotalMilliseconds)
									});
								}
								if (c_02_计算目标伤害.冷却减少分组 != 0 && this.技能来源 is 玩家实例 玩家实例8 && 玩家实例8.冷却记录.TryGetValue(c_02_计算目标伤害.冷却减少分组 | 0, out var v6))
								{
									v6 -= TimeSpan.FromMilliseconds(num12);
									玩家实例8.冷却记录[c_02_计算目标伤害.冷却减少分组 | 0] = v6;
									this.技能来源.发送封包(new 添加技能冷却
									{
										冷却编号 = (c_02_计算目标伤害.冷却减少分组 | 0),
										冷却时间 = Math.Max(0, (int)(v6 - 主程.当前时间).TotalMilliseconds)
									});
								}
							}
						}
						if (c_02_计算目标伤害.命中减少冷却)
						{
							int num13;
							num13 = 0;
							foreach (KeyValuePair<int, 命中详情> item19 in this.命中列表)
							{
								if ((item19.Value.技能反馈 & 技能命中反馈.闪避) == 0 && (item19.Value.技能反馈 & 技能命中反馈.丢失) == 0 && item19.Value.技能目标.特定类型(this.技能来源, c_02_计算目标伤害.冷却减少类型))
								{
									num13 += c_02_计算目标伤害.冷却减少时间;
								}
							}
							if (num13 > 0)
							{
								if (this.技能来源.冷却记录.TryGetValue(c_02_计算目标伤害.冷却减少技能 | 0x1000000, out var v7))
								{
									v7 -= TimeSpan.FromMilliseconds(num13);
									this.技能来源.冷却记录[c_02_计算目标伤害.冷却减少技能 | 0x1000000] = v7;
									this.技能来源.发送封包(new 添加技能冷却
									{
										冷却编号 = (c_02_计算目标伤害.冷却减少技能 | 0x1000000),
										冷却时间 = Math.Max(0, (int)(v7 - 主程.当前时间).TotalMilliseconds)
									});
								}
								if (c_02_计算目标伤害.冷却减少分组 != 0 && this.技能来源 is 玩家实例 玩家实例9 && 玩家实例9.冷却记录.TryGetValue(c_02_计算目标伤害.冷却减少分组 | 0, out var v8))
								{
									v8 -= TimeSpan.FromMilliseconds(num13);
									玩家实例9.冷却记录[c_02_计算目标伤害.冷却减少分组 | 0] = v8;
									this.技能来源.发送封包(new 添加技能冷却
									{
										冷却编号 = (c_02_计算目标伤害.冷却减少分组 | 0),
										冷却时间 = Math.Max(0, (int)(v8 - 主程.当前时间).TotalMilliseconds)
									});
								}
							}
						}
						if (c_02_计算目标伤害.目标硬直时间 > 0)
						{
							foreach (KeyValuePair<int, 命中详情> item20 in this.命中列表)
							{
								if ((item20.Value.技能反馈 & 技能命中反馈.闪避) == 0 && (item20.Value.技能反馈 & 技能命中反馈.丢失) == 0 && item20.Value.技能目标 is 怪物实例 怪物实例 && 怪物实例.怪物级别 != 怪物级别分类.头目首领)
								{
									item20.Value.技能目标.硬直时间 = 主程.当前时间.AddMilliseconds(c_02_计算目标伤害.目标硬直时间);
								}
							}
						}
						if (c_02_计算目标伤害.清除目标状态 && c_02_计算目标伤害.清除状态列表.Count != 0)
						{
							foreach (KeyValuePair<int, 命中详情> item21 in this.命中列表)
							{
								if ((item21.Value.技能反馈 & 技能命中反馈.闪避) != 0 || (item21.Value.技能反馈 & 技能命中反馈.丢失) != 0)
								{
									continue;
								}
								foreach (ushort item22 in c_02_计算目标伤害.清除状态列表)
								{
									item21.Value.技能目标.移除Buff时处理(item22);
								}
							}
						}
						if (c_02_计算目标伤害.增加技能经验 && this.命中列表.Count != 0)
						{
							(this.技能来源 as 玩家实例).技能增加经验(c_02_计算目标伤害.经验技能编号);
						}
						if (c_02_计算目标伤害.扣除武器持久 && this.命中列表.Count != 0)
						{
							(this.技能来源 as 玩家实例).武器损失持久();
						}
					}
					else if (value is C_03_计算对象位移 c_03_计算对象位移)
					{
						byte[] 自身位移次数;
						自身位移次数 = c_03_计算对象位移.自身位移次数;
						byte b;
						b = (byte)((((自身位移次数 != null) ? 自身位移次数.Length : 0) > this.技能等级) ? c_03_计算对象位移.自身位移次数[this.技能等级] : 0);
						if (c_03_计算对象位移.角色自身位移 && (this.释放地图 != this.技能来源.当前地图 || this.分段编号 >= b))
						{
							this.技能来源.发送封包(new 技能释放中断
							{
								对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
								技能编号 = this.技能编号,
								技能等级 = this.技能等级,
								技能铭文 = this.铭文编号,
								动作编号 = this.动作编号,
								技能分段 = this.分段编号
							});
							this.技能来源.发送封包(new 技能释放完成
							{
								技能编号 = this.技能编号,
								动作编号 = this.动作编号
							});
						}
						else if (c_03_计算对象位移.角色自身位移)
						{
							int 数量;
							数量 = (c_03_计算对象位移.推动目标位移 ? c_03_计算对象位移.连续推动数量 : 0);
							byte[] 自身位移距离;
							自身位移距离 = c_03_计算对象位移.自身位移距离;
							int num14;
							num14 = ((((自身位移距离 != null) ? 自身位移距离.Length : 0) > this.技能等级) ? c_03_计算对象位移.自身位移距离[this.技能等级] : 0);
							int num15;
							num15 = ((c_03_计算对象位移.允许超出锚点 || c_03_计算对象位移.锚点反向位移) ? num14 : Math.Min(num14, 计算类.网格距离(this.释放位置, this.技能锚点)));
							Point 锚点;
							锚点 = (c_03_计算对象位移.锚点反向位移 ? 计算类.前方坐标(this.技能来源.当前坐标, 计算类.计算方向(this.技能锚点, this.技能来源.当前坐标), num15) : this.技能锚点);
							if (this.技能来源.能否位移(this.技能来源, 锚点, num15, 数量, c_03_计算对象位移.能否穿越障碍, out var 终点, out var 目标))
							{
								地图对象[] array2;
								array2 = 目标;
								foreach (地图对象 地图对象 in array2)
								{
									if (c_03_计算对象位移.目标位移编号 != 0 && 计算类.计算概率(c_03_计算对象位移.位移Buff概率))
									{
										地图对象.添加Buff时处理(c_03_计算对象位移.目标位移编号, this.技能来源);
									}
									if (c_03_计算对象位移.目标附加编号 != 0 && 计算类.计算概率(c_03_计算对象位移.附加Buff概率) && 地图对象.特定类型(this.技能来源, c_03_计算对象位移.限定附加类型))
									{
										地图对象.添加Buff时处理(c_03_计算对象位移.目标附加编号, this.技能来源);
									}
									地图对象.当前方向 = 计算类.计算方向(地图对象.当前坐标, this.技能来源.当前坐标);
									Point point;
									point = 计算类.前方坐标(地图对象.当前坐标, 计算类.计算方向(this.技能来源.当前坐标, 地图对象.当前坐标), 1);
									地图对象.忙碌时间 = 主程.当前时间.AddMilliseconds(c_03_计算对象位移.目标位移耗时 * 60);
									地图对象.硬直时间 = 主程.当前时间.AddMilliseconds(c_03_计算对象位移.目标位移耗时 * 60 + c_03_计算对象位移.目标硬直时间);
									地图对象.发送封包(new 对象被动位移
									{
										位移坐标 = point,
										对象编号 = 地图对象.地图编号,
										位移朝向 = (ushort)地图对象.当前方向,
										位移速度 = c_03_计算对象位移.目标位移耗时
									});
									地图对象.自身移动时处理(point);
									if (c_03_计算对象位移.推动增加经验 && !this.经验增加)
									{
										(this.技能来源 as 玩家实例).技能增加经验(this.技能编号);
										this.经验增加 = true;
									}
								}
								if (c_03_计算对象位移.成功Buff编号 != 0 && 计算类.计算概率(c_03_计算对象位移.成功Buff概率))
								{
									this.技能来源.添加Buff时处理(c_03_计算对象位移.成功Buff编号, this.技能来源);
								}
								this.技能来源.当前方向 = 计算类.计算方向(this.技能来源.当前坐标, 终点);
								int num16;
								num16 = c_03_计算对象位移.自身位移耗时 * this.技能来源.网格距离(终点);
								this.技能来源.忙碌时间 = 主程.当前时间.AddMilliseconds(num16 * 60);
								this.技能来源.发送封包(new 对象被动位移
								{
									位移坐标 = 终点,
									对象编号 = this.技能来源.地图编号,
									位移朝向 = (ushort)this.技能来源.当前方向,
									位移速度 = (ushort)num16
								});
								this.技能来源.自身移动时处理(终点);
								if (this.技能来源 is 玩家实例 玩家实例10 && c_03_计算对象位移.位移增加经验 && !this.经验增加)
								{
									玩家实例10.技能增加经验(this.技能编号);
									this.经验增加 = true;
								}
								if (c_03_计算对象位移.多段位移通知)
								{
									this.技能来源.发送封包(new 触发技能正常
									{
										对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
										技能编号 = this.技能编号,
										技能等级 = this.技能等级,
										技能铭文 = this.铭文编号,
										动作编号 = this.动作编号,
										技能分段 = this.分段编号
									});
								}
								if (b > 1)
								{
									this.技能锚点 = 计算类.前方坐标(this.技能来源.当前坐标, this.技能来源.当前方向, num15);
								}
								this.分段编号++;
							}
							else
							{
								if (计算类.计算概率(c_03_计算对象位移.失败Buff概率))
								{
									this.技能来源.添加Buff时处理(c_03_计算对象位移.失败Buff编号, this.技能来源);
								}
								this.技能来源.硬直时间 = 主程.当前时间.AddMilliseconds((int)c_03_计算对象位移.自身硬直时间);
								this.分段编号 = b;
							}
							if (b > 1)
							{
								int k;
								for (k = keyValuePair.Key + c_03_计算对象位移.自身位移耗时 * 60; this.节点列表.ContainsKey(k); k++)
								{
								}
								this.节点列表.Add(k, keyValuePair.Value);
							}
						}
						else if (c_03_计算对象位移.推动目标位移)
						{
							foreach (KeyValuePair<int, 命中详情> item23 in this.命中列表)
							{
								if ((item23.Value.技能反馈 & 技能命中反馈.闪避) != 0 || (item23.Value.技能反馈 & 技能命中反馈.丢失) != 0 || (item23.Value.技能反馈 & 技能命中反馈.死亡) != 0 || !计算类.计算概率(c_03_计算对象位移.推动目标概率) || !item23.Value.技能目标.特定类型(this.技能来源, c_03_计算对象位移.推动目标类型))
								{
									continue;
								}
								byte[] 目标位移距离;
								目标位移距离 = c_03_计算对象位移.目标位移距离;
								int num17;
								num17 = Math.Max(0, Math.Min(val2: (((目标位移距离 != null) ? 目标位移距离.Length : 0) > this.技能等级) ? c_03_计算对象位移.目标位移距离[this.技能等级] : 0, val1: 8 - 计算类.网格距离(this.技能来源.当前坐标, item23.Value.技能目标.当前坐标)));
								if (num17 == 0)
								{
									continue;
								}
								Point 锚点2;
								锚点2 = 计算类.前方坐标(方向: 计算类.计算方向(this.技能来源.当前坐标, item23.Value.技能目标.当前坐标), 原点: item23.Value.技能目标.当前坐标, 步数: num17);
								if (item23.Value.技能目标.能否位移(this.技能来源, 锚点2, num17, 0, 穿墙: false, out var 终点2, out var _))
								{
									if (计算类.计算概率(c_03_计算对象位移.位移Buff概率))
									{
										item23.Value.技能目标.添加Buff时处理(c_03_计算对象位移.目标位移编号, this.技能来源);
									}
									if (计算类.计算概率(c_03_计算对象位移.附加Buff概率) && item23.Value.技能目标.特定类型(this.技能来源, c_03_计算对象位移.限定附加类型))
									{
										item23.Value.技能目标.添加Buff时处理(c_03_计算对象位移.目标附加编号, this.技能来源);
									}
									item23.Value.技能目标.当前方向 = 计算类.计算方向(item23.Value.技能目标.当前坐标, this.技能来源.当前坐标);
									ushort num18;
									num18 = (ushort)(计算类.网格距离(item23.Value.技能目标.当前坐标, 终点2) * c_03_计算对象位移.目标位移耗时);
									item23.Value.技能目标.忙碌时间 = 主程.当前时间.AddMilliseconds(num18 * 60);
									item23.Value.技能目标.硬直时间 = 主程.当前时间.AddMilliseconds(num18 * 60 + c_03_计算对象位移.目标硬直时间);
									item23.Value.技能目标.发送封包(new 对象被动位移
									{
										位移坐标 = 终点2,
										位移速度 = num18,
										对象编号 = item23.Value.技能目标.地图编号,
										位移朝向 = (ushort)item23.Value.技能目标.当前方向
									});
									item23.Value.技能目标.自身移动时处理(终点2);
									if (c_03_计算对象位移.推动增加经验 && !this.经验增加)
									{
										(this.技能来源 as 玩家实例).技能增加经验(this.技能编号);
										this.经验增加 = true;
									}
								}
							}
						}
					}
					else if (value is C_04_计算目标诱惑 参数)
					{
						foreach (KeyValuePair<int, 命中详情> item24 in this.命中列表)
						{
							(this.技能来源 as 玩家实例).玩家诱惑目标(this, 参数, item24.Value.技能目标);
						}
					}
					else if (value is C_06_计算宠物召唤 c_06_计算宠物召唤)
					{
						if (c_06_计算宠物召唤.怪物召唤同伴)
						{
							if (c_06_计算宠物召唤.召唤宠物名字 == null || c_06_计算宠物召唤.召唤宠物名字.Length == 0)
							{
								return;
							}
							if (游戏怪物.数据表.TryGetValue(c_06_计算宠物召唤.召唤宠物名字, out var value4))
							{
								new 怪物实例(value4, this.释放地图, int.MaxValue, new Point[1] { this.释放位置 }, 禁止复活: true, 立即刷新: true).存活时间 = 主程.当前时间.AddMinutes(1.0);
							}
						}
						else if (this.技能来源 is 玩家实例 玩家实例11)
						{
							if ((c_06_计算宠物召唤.检查技能铭文 && (!玩家实例11.主体技能表.TryGetValue(this.技能编号, out var v9) || v9.铭文编号 != this.铭文编号)) || c_06_计算宠物召唤.召唤宠物名字 == null || c_06_计算宠物召唤.召唤宠物名字.Length == 0)
							{
								return;
							}
							int num19;
							num19 = ((c_06_计算宠物召唤.召唤宠物数量?.Length > this.技能等级) ? c_06_计算宠物召唤.召唤宠物数量[this.技能等级] : 0);
							if (玩家实例11.宠物列表.Count < num19 && 游戏怪物.数据表.TryGetValue(c_06_计算宠物召唤.召唤宠物名字, out var value5))
							{
								宠物实例 宠物实例;
								宠物实例 = new 宠物实例(等级上限: (byte)((c_06_计算宠物召唤.宠物等级上限?.Length > this.技能等级) ? c_06_计算宠物召唤.宠物等级上限[this.技能等级] : 0), 宠物主人: 玩家实例11, 召唤宠物: value5, 初始等级: this.技能等级, 绑定武器: c_06_计算宠物召唤.宠物绑定武器);
								玩家实例11.网络连接.发送封包(new 同步宠物等级
								{
									宠物编号 = 宠物实例.地图编号,
									宠物等级 = 宠物实例.宠物等级
								});
								玩家实例11.网络连接.发送封包(new 游戏错误提示
								{
									错误代码 = 9473,
									第一参数 = (int)玩家实例11.宠物模式
								});
								玩家实例11.宠物数据.Add(宠物实例.宠物数据);
								玩家实例11.宠物列表.Add(宠物实例);
								if (c_06_计算宠物召唤.增加技能经验)
								{
									玩家实例11.技能增加经验(c_06_计算宠物召唤.经验技能编号);
								}
							}
						}
					}
					else if (value is C_05_计算目标回复 c_05_计算目标回复)
					{
						foreach (KeyValuePair<int, 命中详情> item25 in this.命中列表)
						{
							item25.Value.技能目标.被动回复时处理(this, c_05_计算目标回复);
						}
						if (c_05_计算目标回复.增加技能经验 && this.命中列表.Count != 0)
						{
							(this.技能来源 as 玩家实例).技能增加经验(c_05_计算目标回复.经验技能编号);
						}
					}
					else if (value is C_07_计算目标瞬移 参数2)
					{
						(this.技能来源 as 玩家实例).玩家瞬间移动(this, 参数2);
					}
				}
			}
			if (this.节点列表.Count == 0)
			{
				this.技能来源.技能任务.Remove(this);
				return;
			}
			this.预约时间 = this.释放时间.AddMilliseconds(this.飞行耗时 + this.节点列表.First().Key);
			this.处理任务();
		}

		public void 技能中断()
		{
			this.节点列表.Clear();
			this.技能来源.发送封包(new 技能释放中断
			{
				对象编号 = ((!this.目标借位 || this.技能目标 == null) ? this.技能来源.地图编号 : this.技能目标.地图编号),
				技能编号 = this.技能编号,
				技能等级 = this.技能等级,
				技能铭文 = this.铭文编号,
				动作编号 = this.动作编号,
				技能分段 = this.分段编号
			});
		}
	}
}
